#-------------------------------[知乎：叶枝黎曼]-------------------------
'''
一条单向的铁路线上，依次有编号为 1, 2, …, n 的 n 个火车站。

每个火车站都有一个级别，最低为 1 级。

现有若干趟车次在这条线路上行驶，每一趟都满足如下要求：如果这趟车次停靠了火车站 x，则始发站、终点站之间所有级别大于等于火车站 x 的都必须停靠。（注意：起始站和终点站自然也算作事先已知需要停靠的站点） 

例如，下表是 5 趟车次的运行情况。

其中，前 4 趟车次均满足要求，而第 5 趟车次由于停靠了 3 号火车站（2 级）却未停靠途经的 6 号火车站（亦为 2 级）而不满足要求。

1163900-20170818013814084-1540659827.jpg

现有 m 趟车次的运行情况（全部满足要求），试推算这 n 个火车站至少分为几个不同的级别。

输入格式
第一行包含 2 个正整数 n,m，用一个空格隔开。

第 i+1 行（1≤i≤m）中，首先是一个正整数 si（2≤si≤n），表示第 i 趟车次有 si 个停靠站；接下来有 si 个正整数，表示所有停靠站的编号，从小到大排列。

每两个数之间用一个空格隔开。输入保证所有的车次都满足要求。

输出格式
输出只有一行，包含一个正整数，即 n 个火车站最少划分的级别数。

数据范围
1≤n,m≤1000
输入样例：
9 3 
4 1 3 5 6 
3 3 5 6 
3 1 5 9 
输出样例：
3
'''
def Lin(a,b,c):
    if a not in link.keys():
        link[a] = {b:c}
    else:
        if b not in link[a].keys():
            link[a].update({b:c})
        else:
            link[a][b] = max(link[a][b],c)

def topSort():
    global res
    queue = []
    dis = [1]*(n + 1) + [0]*(m + 1)
    for i in range(1,n+m+1):
        if ind[i] == 0:
            queue.append(i)
    
    while queue:
        curNode = queue.pop(0)
        res = max(res,dis[curNode])
        if curNode not in link.keys():
            continue
        for node in link[curNode].keys():
            ind[node] -= 1
            dis[node] = max(dis[node],dis[curNode] + link[curNode][node])
            if ind[node] == 0:
                queue.append(node)
    
    
    

n,m = map(int,input().split())
link = {}
ind = [0]*(n + m + 1)

for i in range(1,m+1):
    temp = [int(i) for i in input().split()]
    start = temp[1]
    end = temp[-1]
    
    tempAll = set([int(i) for i in range(start,end + 1)])
    lowNodes = list(tempAll - set(temp[1:]))
    highNodes = list(set(temp[1:]))
    
    
    verNode = n + i
    
    for node in lowNodes:
        Lin(node,verNode,0)
        ind[verNode] += 1
    for node in highNodes:
        Lin(verNode,node,1)
        ind[node] += 1


res = 0
topSort()
print(res)
